;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-User; Base: 10 -*-
;;; @(#)$Id: //proj/evcl3/mainline/testcase/tc-13-cl-char.lisp#1 $
(in-package :tc-user)


;;; 13.2.5 char=
(deftest cl-13-05-001 ()
    (dotimes (c 255 t)
      (unless (char= (code-char c) (code-char c)) (return nil)) )
  :boolean t )

(deftest cl-13-05-002 ()
    (dotimes (c 255 t)
      (unless (char/= (code-char c) (code-char (1+ c))) (return nil)) )
  :boolean t )

(deftest cl-13-05-003 ()
    (dotimes (c 255 t)
      (unless (char< (code-char c) (code-char (1+ c))) (return nil)) )
  :boolean t )

(deftest cl-13-05-004 ()
    (dotimes (c 255 t)
      (unless (char> (code-char (1+ c)) (code-char c)) (return nil)) )
  :boolean t )

(deftest cl-13-05-005 () (char= #\a #\a #\a)  :boolean t)
(deftest cl-13-05-006 () (char/= #\a #\b #\c) :boolean t)
(deftest cl-13-05-008 () (char/= #\a #\b #\c #\a) nil)
(deftest cl-13-05-009 () (char/= #\a #\b #\c #\b) nil)
(deftest cl-13-05-010 () (char< #\a #\b #\c) :boolean t)
(deftest cl-13-05-011 () (char> #\c #\b #\a) :boolean t)

(deftest cl-13-05-012 () (char-equal #\a #\a #\a)  :boolean t)
(deftest cl-13-05-013 () (char-not-equal #\a #\b #\c) :boolean t)

(deftest cl-13-05-014 () (char-not-equal #\a #\b #\c #\a) nil)
(deftest cl-13-05-015 () (char-not-equal #\a #\b #\c #\b) nil)

(deftest cl-13-05-016 () (char-lessp #\a #\b #\c) :boolean t)
(deftest cl-13-05-017 () (char-greaterp #\c #\b #\a) :boolean t)


;;;; 13.2.8 alpha-char-p
(deftest cl-13-08-001 () (alpha-char-p #\Backspace)  nil)
(deftest cl-13-08-002 () (alpha-char-p #\Linefeed)   nil)
(deftest cl-13-08-003 () (alpha-char-p #\Newline)    nil)
(deftest cl-13-08-004 () (alpha-char-p #\Page)       nil)
(deftest cl-13-08-005 () (alpha-char-p #\Return)     nil)
(deftest cl-13-08-006 () (alpha-char-p #\Rubout)     nil)
(deftest cl-13-08-007 () (alpha-char-p #\Space)      nil)
(deftest cl-13-08-008 () (alpha-char-p #\Tab)        nil)
(deftest cl-13-08-009 () (alpha-char-p #\!) nil)
(deftest cl-13-08-010 () (alpha-char-p #\") nil)
(deftest cl-13-08-011 () (alpha-char-p #\#) nil)
(deftest cl-13-08-012 () (alpha-char-p #\$) nil)
(deftest cl-13-08-013 () (alpha-char-p #\%) nil)
(deftest cl-13-08-014 () (alpha-char-p #\&) nil)
(deftest cl-13-08-015 () (alpha-char-p #\') nil)
(deftest cl-13-08-016 () (alpha-char-p #\() nil)
(deftest cl-13-08-017 () (alpha-char-p #\)) nil)
(deftest cl-13-08-018 () (alpha-char-p #\*) nil)
(deftest cl-13-08-019 () (alpha-char-p #\+) nil)
(deftest cl-13-08-020 () (alpha-char-p #\,) nil)
(deftest cl-13-08-021 () (alpha-char-p #\-) nil)
(deftest cl-13-08-022 () (alpha-char-p #\.) nil)
(deftest cl-13-08-023 () (alpha-char-p #\/) nil)
(deftest cl-13-08-024 () (alpha-char-p #\0) nil)
(deftest cl-13-08-025 () (alpha-char-p #\1) nil)
(deftest cl-13-08-026 () (alpha-char-p #\2) nil)
(deftest cl-13-08-027 () (alpha-char-p #\3) nil)
(deftest cl-13-08-028 () (alpha-char-p #\4) nil)
(deftest cl-13-08-029 () (alpha-char-p #\5) nil)
(deftest cl-13-08-030 () (alpha-char-p #\6) nil)
(deftest cl-13-08-031 () (alpha-char-p #\7) nil)
(deftest cl-13-08-032 () (alpha-char-p #\8) nil)
(deftest cl-13-08-033 () (alpha-char-p #\9) nil)
(deftest cl-13-08-034 () (alpha-char-p #\:) nil)
(deftest cl-13-08-035 () (alpha-char-p #\;) nil)
(deftest cl-13-08-036 () (alpha-char-p #\<) nil)
(deftest cl-13-08-037 () (alpha-char-p #\=) nil)
(deftest cl-13-08-038 () (alpha-char-p #\>) nil)
(deftest cl-13-08-039 () (alpha-char-p #\?) nil)
(deftest cl-13-08-064 () (alpha-char-p #\@) nil)
(deftest cl-13-08-065 () (alpha-char-p #\A) :boolean t)
(deftest cl-13-08-066 () (alpha-char-p #\B) :boolean t)
(deftest cl-13-08-067 () (alpha-char-p #\C) :boolean t)
(deftest cl-13-08-068 () (alpha-char-p #\D) :boolean t)
(deftest cl-13-08-069 () (alpha-char-p #\E) :boolean t)
(deftest cl-13-08-070 () (alpha-char-p #\F) :boolean t)
(deftest cl-13-08-071 () (alpha-char-p #\G) :boolean t)
(deftest cl-13-08-072 () (alpha-char-p #\H) :boolean t)
(deftest cl-13-08-073 () (alpha-char-p #\I) :boolean t)
(deftest cl-13-08-074 () (alpha-char-p #\J) :boolean t)
(deftest cl-13-08-075 () (alpha-char-p #\K) :boolean t)
(deftest cl-13-08-076 () (alpha-char-p #\L) :boolean t)
(deftest cl-13-08-077 () (alpha-char-p #\M) :boolean t)
(deftest cl-13-08-078 () (alpha-char-p #\N) :boolean t)
(deftest cl-13-08-079 () (alpha-char-p #\O) :boolean t)
(deftest cl-13-08-080 () (alpha-char-p #\P) :boolean t)
(deftest cl-13-08-081 () (alpha-char-p #\Q) :boolean t)
(deftest cl-13-08-082 () (alpha-char-p #\R) :boolean t)
(deftest cl-13-08-083 () (alpha-char-p #\S) :boolean t)
(deftest cl-13-08-084 () (alpha-char-p #\T) :boolean t)
(deftest cl-13-08-085 () (alpha-char-p #\U) :boolean t)
(deftest cl-13-08-086 () (alpha-char-p #\V) :boolean t)
(deftest cl-13-08-087 () (alpha-char-p #\W) :boolean t)
(deftest cl-13-08-088 () (alpha-char-p #\X) :boolean t)
(deftest cl-13-08-089 () (alpha-char-p #\Y) :boolean t)
(deftest cl-13-08-090 () (alpha-char-p #\Z) :boolean t)
(deftest cl-13-08-091 () (alpha-char-p #\[) nil)
(deftest cl-13-08-092 () (alpha-char-p #\\) nil)
(deftest cl-13-08-093 () (alpha-char-p #\]) nil)
(deftest cl-13-08-094 () (alpha-char-p #\^) nil)
(deftest cl-13-08-095 () (alpha-char-p #\_) nil)
(deftest cl-13-08-096 () (alpha-char-p #\`) nil)
(deftest cl-13-08-097 () (alpha-char-p #\a) :boolean t)
(deftest cl-13-08-098 () (alpha-char-p #\b) :boolean t)
(deftest cl-13-08-099 () (alpha-char-p #\c) :boolean t)
(deftest cl-13-08-100 () (alpha-char-p #\d) :boolean t)
(deftest cl-13-08-101 () (alpha-char-p #\e) :boolean t)
(deftest cl-13-08-102 () (alpha-char-p #\f) :boolean t)
(deftest cl-13-08-103 () (alpha-char-p #\g) :boolean t)
(deftest cl-13-08-104 () (alpha-char-p #\h) :boolean t)
(deftest cl-13-08-105 () (alpha-char-p #\i) :boolean t)
(deftest cl-13-08-106 () (alpha-char-p #\j) :boolean t)
(deftest cl-13-08-107 () (alpha-char-p #\k) :boolean t)
(deftest cl-13-08-108 () (alpha-char-p #\l) :boolean t)
(deftest cl-13-08-109 () (alpha-char-p #\m) :boolean t)
(deftest cl-13-08-110 () (alpha-char-p #\n) :boolean t)
(deftest cl-13-08-111 () (alpha-char-p #\o) :boolean t)
(deftest cl-13-08-112 () (alpha-char-p #\p) :boolean t)
(deftest cl-13-08-113 () (alpha-char-p #\q) :boolean t)
(deftest cl-13-08-114 () (alpha-char-p #\r) :boolean t)
(deftest cl-13-08-115 () (alpha-char-p #\s) :boolean t)
(deftest cl-13-08-116 () (alpha-char-p #\t) :boolean t)
(deftest cl-13-08-117 () (alpha-char-p #\u) :boolean t)
(deftest cl-13-08-118 () (alpha-char-p #\v) :boolean t)
(deftest cl-13-08-119 () (alpha-char-p #\w) :boolean t)
(deftest cl-13-08-120 () (alpha-char-p #\x) :boolean t)
(deftest cl-13-08-121 () (alpha-char-p #\y) :boolean t)
(deftest cl-13-08-122 () (alpha-char-p #\z) :boolean t)
(deftest cl-13-08-123 () (alpha-char-p #\{) nil)
(deftest cl-13-08-124 () (alpha-char-p #\|) nil)
(deftest cl-13-08-125 () (alpha-char-p #\}) nil)
(deftest cl-13-08-126 () (alpha-char-p #\~) nil)

;;; 13.2.9 alphanumericp
(deftest cl-13-09-008 () (alphanumericp #\Backspace)  nil)
(deftest cl-13-09-010 () (alphanumericp #\Linefeed)   nil)
(deftest cl-13-09-011 () (alphanumericp #\Newline)    nil)
(deftest cl-13-09-012 () (alphanumericp #\Page)       nil)
(deftest cl-13-09-013 () (alphanumericp #\Return)     nil)
(deftest cl-13-09-127 () (alphanumericp #\Rubout)     nil)
(deftest cl-13-09-032 () (alphanumericp #\Space)      nil)
(deftest cl-13-09-009 () (alphanumericp #\Tab)        nil)
(deftest cl-13-09-033 () (alphanumericp #\!) nil)
(deftest cl-13-09-034 () (alphanumericp #\") nil)
(deftest cl-13-09-035 () (alphanumericp #\#) nil)
(deftest cl-13-09-036 () (alphanumericp #\$) nil)
(deftest cl-13-09-037 () (alphanumericp #\%) nil)
(deftest cl-13-09-038 () (alphanumericp #\&) nil)
(deftest cl-13-09-039 () (alphanumericp #\') nil)
(deftest cl-13-09-040 () (alphanumericp #\() nil)
(deftest cl-13-09-041 () (alphanumericp #\)) nil)
(deftest cl-13-09-042 () (alphanumericp #\*) nil)
(deftest cl-13-09-043 () (alphanumericp #\+) nil)
(deftest cl-13-09-044 () (alphanumericp #\,) nil)
(deftest cl-13-09-045 () (alphanumericp #\-) nil)
(deftest cl-13-09-046 () (alphanumericp #\.) nil)
(deftest cl-13-09-047 () (alphanumericp #\/) nil)
(deftest cl-13-09-048 () (alphanumericp #\0) :boolean t)
(deftest cl-13-09-049 () (alphanumericp #\1) :boolean t)
(deftest cl-13-09-050 () (alphanumericp #\2) :boolean t)
(deftest cl-13-09-051 () (alphanumericp #\3) :boolean t)
(deftest cl-13-09-052 () (alphanumericp #\4) :boolean t)
(deftest cl-13-09-053 () (alphanumericp #\5) :boolean t)
(deftest cl-13-09-054 () (alphanumericp #\6) :boolean t)
(deftest cl-13-09-055 () (alphanumericp #\7) :boolean t)
(deftest cl-13-09-056 () (alphanumericp #\8) :boolean t)
(deftest cl-13-09-057 () (alphanumericp #\9) :boolean t)
(deftest cl-13-09-058 () (alphanumericp #\:) nil)
(deftest cl-13-09-059 () (alphanumericp #\;) nil)
(deftest cl-13-09-060 () (alphanumericp #\<) nil)
(deftest cl-13-09-061 () (alphanumericp #\=) nil)
(deftest cl-13-09-062 () (alphanumericp #\>) nil)
(deftest cl-13-09-063 () (alphanumericp #\?) nil)
(deftest cl-13-09-064 () (alphanumericp #\@) nil)
(deftest cl-13-09-065 () (alphanumericp #\A) :boolean t)
(deftest cl-13-09-066 () (alphanumericp #\B) :boolean t)
(deftest cl-13-09-067 () (alphanumericp #\C) :boolean t)
(deftest cl-13-09-068 () (alphanumericp #\D) :boolean t)
(deftest cl-13-09-069 () (alphanumericp #\E) :boolean t)
(deftest cl-13-09-070 () (alphanumericp #\F) :boolean t)
(deftest cl-13-09-071 () (alphanumericp #\G) :boolean t)
(deftest cl-13-09-072 () (alphanumericp #\H) :boolean t)
(deftest cl-13-09-073 () (alphanumericp #\I) :boolean t)
(deftest cl-13-09-074 () (alphanumericp #\J) :boolean t)
(deftest cl-13-09-075 () (alphanumericp #\K) :boolean t)
(deftest cl-13-09-076 () (alphanumericp #\L) :boolean t)
(deftest cl-13-09-077 () (alphanumericp #\M) :boolean t)
(deftest cl-13-09-078 () (alphanumericp #\N) :boolean t)
(deftest cl-13-09-079 () (alphanumericp #\O) :boolean t)
(deftest cl-13-09-080 () (alphanumericp #\P) :boolean t)
(deftest cl-13-09-081 () (alphanumericp #\Q) :boolean t)
(deftest cl-13-09-082 () (alphanumericp #\R) :boolean t)
(deftest cl-13-09-083 () (alphanumericp #\S) :boolean t)
(deftest cl-13-09-084 () (alphanumericp #\T) :boolean t)
(deftest cl-13-09-085 () (alphanumericp #\U) :boolean t)
(deftest cl-13-09-086 () (alphanumericp #\V) :boolean t)
(deftest cl-13-09-087 () (alphanumericp #\W) :boolean t)
(deftest cl-13-09-088 () (alphanumericp #\X) :boolean t)
(deftest cl-13-09-089 () (alphanumericp #\Y) :boolean t)
(deftest cl-13-09-090 () (alphanumericp #\Z) :boolean t)
(deftest cl-13-09-091 () (alphanumericp #\[) nil)
(deftest cl-13-09-092 () (alphanumericp #\\) nil)
(deftest cl-13-09-093 () (alphanumericp #\]) nil)
(deftest cl-13-09-094 () (alphanumericp #\^) nil)
(deftest cl-13-09-095 () (alphanumericp #\_) nil)
(deftest cl-13-09-096 () (alphanumericp #\`) nil)
(deftest cl-13-09-097 () (alphanumericp #\a) :boolean t)
(deftest cl-13-09-098 () (alphanumericp #\b) :boolean t)
(deftest cl-13-09-099 () (alphanumericp #\c) :boolean t)
(deftest cl-13-09-100 () (alphanumericp #\d) :boolean t)
(deftest cl-13-09-101 () (alphanumericp #\e) :boolean t)
(deftest cl-13-09-102 () (alphanumericp #\f) :boolean t)
(deftest cl-13-09-103 () (alphanumericp #\g) :boolean t)
(deftest cl-13-09-104 () (alphanumericp #\h) :boolean t)
(deftest cl-13-09-105 () (alphanumericp #\i) :boolean t)
(deftest cl-13-09-106 () (alphanumericp #\j) :boolean t)
(deftest cl-13-09-107 () (alphanumericp #\k) :boolean t)
(deftest cl-13-09-108 () (alphanumericp #\l) :boolean t)
(deftest cl-13-09-109 () (alphanumericp #\m) :boolean t)
(deftest cl-13-09-110 () (alphanumericp #\n) :boolean t)
(deftest cl-13-09-111 () (alphanumericp #\o) :boolean t)
(deftest cl-13-09-112 () (alphanumericp #\p) :boolean t)
(deftest cl-13-09-113 () (alphanumericp #\q) :boolean t)
(deftest cl-13-09-114 () (alphanumericp #\r) :boolean t)
(deftest cl-13-09-115 () (alphanumericp #\s) :boolean t)
(deftest cl-13-09-116 () (alphanumericp #\t) :boolean t)
(deftest cl-13-09-117 () (alphanumericp #\u) :boolean t)
(deftest cl-13-09-118 () (alphanumericp #\v) :boolean t)
(deftest cl-13-09-119 () (alphanumericp #\w) :boolean t)
(deftest cl-13-09-120 () (alphanumericp #\x) :boolean t)
(deftest cl-13-09-121 () (alphanumericp #\y) :boolean t)
(deftest cl-13-09-122 () (alphanumericp #\z) :boolean t)
(deftest cl-13-09-123 () (alphanumericp #\{) nil)
(deftest cl-13-09-124 () (alphanumericp #\|) nil)
(deftest cl-13-09-125 () (alphanumericp #\}) nil)
(deftest cl-13-09-126 () (alphanumericp #\~) nil)


;;;; 13.2.10 digit-char
#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-18-~3,'0D () (code-char #x~2,'0X) ~S)~%"
        code code char ))

(deftest cl-13-10-000 () (digit-char 0)  #\0)
(deftest cl-13-10-001 () (digit-char 1)  #\1)
(deftest cl-13-10-002 () (digit-char 2)  #\2)
(deftest cl-13-10-003 () (digit-char 3)  #\3)
(deftest cl-13-10-004 () (digit-char 4)  #\4)
(deftest cl-13-10-005 () (digit-char 5)  #\5)
(deftest cl-13-10-006 () (digit-char 6)  #\6)
(deftest cl-13-10-007 () (digit-char 7)  #\7)
(deftest cl-13-10-008 () (digit-char 8)  #\8)
(deftest cl-13-10-009 () (digit-char 9)  #\9)
(deftest cl-13-10-010 () (digit-char 10) nil)
(deftest cl-13-10-011 () (digit-char 11) nil)
(deftest cl-13-10-012 () (digit-char 12) nil)
(deftest cl-13-10-013 () (digit-char 13) nil)
(deftest cl-13-10-014 () (digit-char 14) nil)
(deftest cl-13-10-015 () (digit-char 15) nil)
(deftest cl-13-10-016 () (digit-char 16) nil)
(deftest cl-13-10-017 () (digit-char 17) nil)
(deftest cl-13-10-018 () (digit-char -1) :error type-error)

(deftest cl-13-10-019 () (digit-char 0 16)  #\0)
(deftest cl-13-10-020 () (digit-char 1 16)  #\1)
(deftest cl-13-10-021 () (digit-char 2 16)  #\2)
(deftest cl-13-10-022 () (digit-char 3 16)  #\3)
(deftest cl-13-10-023 () (digit-char 4 16)  #\4)
(deftest cl-13-10-024 () (digit-char 5 16)  #\5)
(deftest cl-13-10-025 () (digit-char 6 16)  #\6)
(deftest cl-13-10-026 () (digit-char 7 16)  #\7)
(deftest cl-13-10-027 () (digit-char 8 16)  #\8)
(deftest cl-13-10-028 () (digit-char 9 16)  #\9)
(deftest cl-13-10-029 () (digit-char 10 16) #\A)
(deftest cl-13-10-030 () (digit-char 11 16) #\B)
(deftest cl-13-10-031 () (digit-char 12 16) #\C)
(deftest cl-13-10-032 () (digit-char 13 16) #\D)
(deftest cl-13-10-033 () (digit-char 14 16) #\E)
(deftest cl-13-10-034 () (digit-char 15 16) #\F)
(deftest cl-13-10-035 () (digit-char 16 16) nil)
(deftest cl-13-10-036 () (digit-char 17 16) nil)
(deftest cl-13-10-037 () (digit-char -1 16) :error type-error)

;;;; 13.2.11 digit-char-p
#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-11-~3,'0D () (digit-char-p ~S) :boolean ~S)~%"
        code char (not (null (digit-char-p char))) ))

(deftest cl-13-11-008 () (digit-char-p #\Backspace) :boolean nil)
(deftest cl-13-11-009 () (digit-char-p #\Tab) :boolean nil)
(deftest cl-13-11-010 () (digit-char-p #\Newline) :boolean nil)
(deftest cl-13-11-012 () (digit-char-p #\Page) :boolean nil)
(deftest cl-13-11-027 () (digit-char-p #\Escape) :boolean nil)
(deftest cl-13-11-032 () (digit-char-p #\Space) :boolean nil)
(deftest cl-13-11-033 () (digit-char-p #\!) :boolean nil)
(deftest cl-13-11-034 () (digit-char-p #\") :boolean nil)
(deftest cl-13-11-035 () (digit-char-p #\#) :boolean nil)
(deftest cl-13-11-036 () (digit-char-p #\$) :boolean nil)
(deftest cl-13-11-037 () (digit-char-p #\%) :boolean nil)
(deftest cl-13-11-038 () (digit-char-p #\&) :boolean nil)
(deftest cl-13-11-039 () (digit-char-p #\') :boolean nil)
(deftest cl-13-11-040 () (digit-char-p #\() :boolean nil)
(deftest cl-13-11-041 () (digit-char-p #\)) :boolean nil)
(deftest cl-13-11-042 () (digit-char-p #\*) :boolean nil)
(deftest cl-13-11-043 () (digit-char-p #\+) :boolean nil)
(deftest cl-13-11-044 () (digit-char-p #\,) :boolean nil)
(deftest cl-13-11-045 () (digit-char-p #\-) :boolean nil)
(deftest cl-13-11-046 () (digit-char-p #\.) :boolean nil)
(deftest cl-13-11-047 () (digit-char-p #\/) :boolean nil)
(deftest cl-13-11-048 () (digit-char-p #\0) :boolean T)
(deftest cl-13-11-049 () (digit-char-p #\1) :boolean T)
(deftest cl-13-11-050 () (digit-char-p #\2) :boolean T)
(deftest cl-13-11-051 () (digit-char-p #\3) :boolean T)
(deftest cl-13-11-052 () (digit-char-p #\4) :boolean T)
(deftest cl-13-11-053 () (digit-char-p #\5) :boolean T)
(deftest cl-13-11-054 () (digit-char-p #\6) :boolean T)
(deftest cl-13-11-055 () (digit-char-p #\7) :boolean T)
(deftest cl-13-11-056 () (digit-char-p #\8) :boolean T)
(deftest cl-13-11-057 () (digit-char-p #\9) :boolean T)
(deftest cl-13-11-058 () (digit-char-p #\:) :boolean nil)
(deftest cl-13-11-059 () (digit-char-p #\;) :boolean nil)
(deftest cl-13-11-060 () (digit-char-p #\<) :boolean nil)
(deftest cl-13-11-061 () (digit-char-p #\=) :boolean nil)
(deftest cl-13-11-062 () (digit-char-p #\>) :boolean nil)
(deftest cl-13-11-063 () (digit-char-p #\?) :boolean nil)
(deftest cl-13-11-064 () (digit-char-p #\@) :boolean nil)
(deftest cl-13-11-065 () (digit-char-p #\A) :boolean nil)
(deftest cl-13-11-066 () (digit-char-p #\B) :boolean nil)
(deftest cl-13-11-067 () (digit-char-p #\C) :boolean nil)
(deftest cl-13-11-068 () (digit-char-p #\D) :boolean nil)
(deftest cl-13-11-069 () (digit-char-p #\E) :boolean nil)
(deftest cl-13-11-070 () (digit-char-p #\F) :boolean nil)
(deftest cl-13-11-071 () (digit-char-p #\G) :boolean nil)
(deftest cl-13-11-072 () (digit-char-p #\H) :boolean nil)
(deftest cl-13-11-073 () (digit-char-p #\I) :boolean nil)
(deftest cl-13-11-074 () (digit-char-p #\J) :boolean nil)
(deftest cl-13-11-075 () (digit-char-p #\K) :boolean nil)
(deftest cl-13-11-076 () (digit-char-p #\L) :boolean nil)
(deftest cl-13-11-077 () (digit-char-p #\M) :boolean nil)
(deftest cl-13-11-078 () (digit-char-p #\N) :boolean nil)
(deftest cl-13-11-079 () (digit-char-p #\O) :boolean nil)
(deftest cl-13-11-080 () (digit-char-p #\P) :boolean nil)
(deftest cl-13-11-081 () (digit-char-p #\Q) :boolean nil)
(deftest cl-13-11-082 () (digit-char-p #\R) :boolean nil)
(deftest cl-13-11-083 () (digit-char-p #\S) :boolean nil)
(deftest cl-13-11-084 () (digit-char-p #\T) :boolean nil)
(deftest cl-13-11-085 () (digit-char-p #\U) :boolean nil)
(deftest cl-13-11-086 () (digit-char-p #\V) :boolean nil)
(deftest cl-13-11-087 () (digit-char-p #\W) :boolean nil)
(deftest cl-13-11-088 () (digit-char-p #\X) :boolean nil)
(deftest cl-13-11-089 () (digit-char-p #\Y) :boolean nil)
(deftest cl-13-11-090 () (digit-char-p #\Z) :boolean nil)
(deftest cl-13-11-091 () (digit-char-p #\[) :boolean nil)
(deftest cl-13-11-092 () (digit-char-p #\\) :boolean nil)
(deftest cl-13-11-093 () (digit-char-p #\]) :boolean nil)
(deftest cl-13-11-094 () (digit-char-p #\^) :boolean nil)
(deftest cl-13-11-095 () (digit-char-p #\_) :boolean nil)
(deftest cl-13-11-096 () (digit-char-p #\`) :boolean nil)
(deftest cl-13-11-097 () (digit-char-p #\a) :boolean nil)
(deftest cl-13-11-098 () (digit-char-p #\b) :boolean nil)
(deftest cl-13-11-099 () (digit-char-p #\c) :boolean nil)
(deftest cl-13-11-100 () (digit-char-p #\d) :boolean nil)
(deftest cl-13-11-101 () (digit-char-p #\e) :boolean nil)
(deftest cl-13-11-102 () (digit-char-p #\f) :boolean nil)
(deftest cl-13-11-103 () (digit-char-p #\g) :boolean nil)
(deftest cl-13-11-104 () (digit-char-p #\h) :boolean nil)
(deftest cl-13-11-105 () (digit-char-p #\i) :boolean nil)
(deftest cl-13-11-106 () (digit-char-p #\j) :boolean nil)
(deftest cl-13-11-107 () (digit-char-p #\k) :boolean nil)
(deftest cl-13-11-108 () (digit-char-p #\l) :boolean nil)
(deftest cl-13-11-109 () (digit-char-p #\m) :boolean nil)
(deftest cl-13-11-110 () (digit-char-p #\n) :boolean nil)
(deftest cl-13-11-111 () (digit-char-p #\o) :boolean nil)
(deftest cl-13-11-112 () (digit-char-p #\p) :boolean nil)
(deftest cl-13-11-113 () (digit-char-p #\q) :boolean nil)
(deftest cl-13-11-114 () (digit-char-p #\r) :boolean nil)
(deftest cl-13-11-115 () (digit-char-p #\s) :boolean nil)
(deftest cl-13-11-116 () (digit-char-p #\t) :boolean nil)
(deftest cl-13-11-117 () (digit-char-p #\u) :boolean nil)
(deftest cl-13-11-118 () (digit-char-p #\v) :boolean nil)
(deftest cl-13-11-119 () (digit-char-p #\w) :boolean nil)
(deftest cl-13-11-120 () (digit-char-p #\x) :boolean nil)
(deftest cl-13-11-121 () (digit-char-p #\y) :boolean nil)
(deftest cl-13-11-122 () (digit-char-p #\z) :boolean nil)
(deftest cl-13-11-123 () (digit-char-p #\{) :boolean nil)
(deftest cl-13-11-124 () (digit-char-p #\|) :boolean nil)
(deftest cl-13-11-125 () (digit-char-p #\}) :boolean nil)
(deftest cl-13-11-126 () (digit-char-p #\~) :boolean nil)

#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-11-~3,'0D () (digit-char-p ~S 16) :boolean ~S)~%"
        code char (not (null (digit-char-p char 16))) ))


(deftest cl-13-11-008 () (digit-char-p #\Backspace 16) :boolean nil)
(deftest cl-13-11-009 () (digit-char-p #\Tab 16) :boolean nil)
(deftest cl-13-11-010 () (digit-char-p #\Newline 16) :boolean nil)
(deftest cl-13-11-012 () (digit-char-p #\Page 16) :boolean nil)
(deftest cl-13-11-027 () (digit-char-p #\Escape 16) :boolean nil)
(deftest cl-13-11-032 () (digit-char-p #\Space 16) :boolean nil)
(deftest cl-13-11-033 () (digit-char-p #\! 16) :boolean nil)
(deftest cl-13-11-034 () (digit-char-p #\" 16) :boolean nil)
(deftest cl-13-11-035 () (digit-char-p #\# 16) :boolean nil)
(deftest cl-13-11-036 () (digit-char-p #\$ 16) :boolean nil)
(deftest cl-13-11-037 () (digit-char-p #\% 16) :boolean nil)
(deftest cl-13-11-038 () (digit-char-p #\& 16) :boolean nil)
(deftest cl-13-11-039 () (digit-char-p #\' 16) :boolean nil)
(deftest cl-13-11-040 () (digit-char-p #\( 16) :boolean nil)
(deftest cl-13-11-041 () (digit-char-p #\) 16) :boolean nil)
(deftest cl-13-11-042 () (digit-char-p #\* 16) :boolean nil)
(deftest cl-13-11-043 () (digit-char-p #\+ 16) :boolean nil)
(deftest cl-13-11-044 () (digit-char-p #\, 16) :boolean nil)
(deftest cl-13-11-045 () (digit-char-p #\- 16) :boolean nil)
(deftest cl-13-11-046 () (digit-char-p #\. 16) :boolean nil)
(deftest cl-13-11-047 () (digit-char-p #\/ 16) :boolean nil)
(deftest cl-13-11-048 () (digit-char-p #\0 16) :boolean T)
(deftest cl-13-11-049 () (digit-char-p #\1 16) :boolean T)
(deftest cl-13-11-050 () (digit-char-p #\2 16) :boolean T)
(deftest cl-13-11-051 () (digit-char-p #\3 16) :boolean T)
(deftest cl-13-11-052 () (digit-char-p #\4 16) :boolean T)
(deftest cl-13-11-053 () (digit-char-p #\5 16) :boolean T)
(deftest cl-13-11-054 () (digit-char-p #\6 16) :boolean T)
(deftest cl-13-11-055 () (digit-char-p #\7 16) :boolean T)
(deftest cl-13-11-056 () (digit-char-p #\8 16) :boolean T)
(deftest cl-13-11-057 () (digit-char-p #\9 16) :boolean T)
(deftest cl-13-11-058 () (digit-char-p #\: 16) :boolean nil)
(deftest cl-13-11-059 () (digit-char-p #\; 16) :boolean nil)
(deftest cl-13-11-060 () (digit-char-p #\< 16) :boolean nil)
(deftest cl-13-11-061 () (digit-char-p #\= 16) :boolean nil)
(deftest cl-13-11-062 () (digit-char-p #\> 16) :boolean nil)
(deftest cl-13-11-063 () (digit-char-p #\? 16) :boolean nil)
(deftest cl-13-11-064 () (digit-char-p #\@ 16) :boolean nil)
(deftest cl-13-11-065 () (digit-char-p #\A 16) :boolean T)
(deftest cl-13-11-066 () (digit-char-p #\B 16) :boolean T)
(deftest cl-13-11-067 () (digit-char-p #\C 16) :boolean T)
(deftest cl-13-11-068 () (digit-char-p #\D 16) :boolean T)
(deftest cl-13-11-069 () (digit-char-p #\E 16) :boolean T)
(deftest cl-13-11-070 () (digit-char-p #\F 16) :boolean T)
(deftest cl-13-11-071 () (digit-char-p #\G 16) :boolean nil)
(deftest cl-13-11-072 () (digit-char-p #\H 16) :boolean nil)
(deftest cl-13-11-073 () (digit-char-p #\I 16) :boolean nil)
(deftest cl-13-11-074 () (digit-char-p #\J 16) :boolean nil)
(deftest cl-13-11-075 () (digit-char-p #\K 16) :boolean nil)
(deftest cl-13-11-076 () (digit-char-p #\L 16) :boolean nil)
(deftest cl-13-11-077 () (digit-char-p #\M 16) :boolean nil)
(deftest cl-13-11-078 () (digit-char-p #\N 16) :boolean nil)
(deftest cl-13-11-079 () (digit-char-p #\O 16) :boolean nil)
(deftest cl-13-11-080 () (digit-char-p #\P 16) :boolean nil)
(deftest cl-13-11-081 () (digit-char-p #\Q 16) :boolean nil)
(deftest cl-13-11-082 () (digit-char-p #\R 16) :boolean nil)
(deftest cl-13-11-083 () (digit-char-p #\S 16) :boolean nil)
(deftest cl-13-11-084 () (digit-char-p #\T 16) :boolean nil)
(deftest cl-13-11-085 () (digit-char-p #\U 16) :boolean nil)
(deftest cl-13-11-086 () (digit-char-p #\V 16) :boolean nil)
(deftest cl-13-11-087 () (digit-char-p #\W 16) :boolean nil)
(deftest cl-13-11-088 () (digit-char-p #\X 16) :boolean nil)
(deftest cl-13-11-089 () (digit-char-p #\Y 16) :boolean nil)
(deftest cl-13-11-090 () (digit-char-p #\Z 16) :boolean nil)
(deftest cl-13-11-091 () (digit-char-p #\[ 16) :boolean nil)
(deftest cl-13-11-092 () (digit-char-p #\\ 16) :boolean nil)
(deftest cl-13-11-093 () (digit-char-p #\] 16) :boolean nil)
(deftest cl-13-11-094 () (digit-char-p #\^ 16) :boolean nil)
(deftest cl-13-11-095 () (digit-char-p #\_ 16) :boolean nil)
(deftest cl-13-11-096 () (digit-char-p #\` 16) :boolean nil)
(deftest cl-13-11-097 () (digit-char-p #\a 16) :boolean T)
(deftest cl-13-11-098 () (digit-char-p #\b 16) :boolean T)
(deftest cl-13-11-099 () (digit-char-p #\c 16) :boolean T)
(deftest cl-13-11-100 () (digit-char-p #\d 16) :boolean T)
(deftest cl-13-11-101 () (digit-char-p #\e 16) :boolean T)
(deftest cl-13-11-102 () (digit-char-p #\f 16) :boolean T)
(deftest cl-13-11-103 () (digit-char-p #\g 16) :boolean nil)
(deftest cl-13-11-104 () (digit-char-p #\h 16) :boolean nil)
(deftest cl-13-11-105 () (digit-char-p #\i 16) :boolean nil)
(deftest cl-13-11-106 () (digit-char-p #\j 16) :boolean nil)
(deftest cl-13-11-107 () (digit-char-p #\k 16) :boolean nil)
(deftest cl-13-11-108 () (digit-char-p #\l 16) :boolean nil)
(deftest cl-13-11-109 () (digit-char-p #\m 16) :boolean nil)
(deftest cl-13-11-110 () (digit-char-p #\n 16) :boolean nil)
(deftest cl-13-11-111 () (digit-char-p #\o 16) :boolean nil)
(deftest cl-13-11-112 () (digit-char-p #\p 16) :boolean nil)
(deftest cl-13-11-113 () (digit-char-p #\q 16) :boolean nil)
(deftest cl-13-11-114 () (digit-char-p #\r 16) :boolean nil)
(deftest cl-13-11-115 () (digit-char-p #\s 16) :boolean nil)
(deftest cl-13-11-116 () (digit-char-p #\t 16) :boolean nil)
(deftest cl-13-11-117 () (digit-char-p #\u 16) :boolean nil)
(deftest cl-13-11-118 () (digit-char-p #\v 16) :boolean nil)
(deftest cl-13-11-119 () (digit-char-p #\w 16) :boolean nil)
(deftest cl-13-11-120 () (digit-char-p #\x 16) :boolean nil)
(deftest cl-13-11-121 () (digit-char-p #\y 16) :boolean nil)
(deftest cl-13-11-122 () (digit-char-p #\z 16) :boolean nil)
(deftest cl-13-11-123 () (digit-char-p #\{ 16) :boolean nil)
(deftest cl-13-11-124 () (digit-char-p #\| 16) :boolean nil)
(deftest cl-13-11-125 () (digit-char-p #\} 16) :boolean nil)
(deftest cl-13-11-126 () (digit-char-p #\~ 16) :boolean nil)

;;; 13.2.14 char-downcase
#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-14-~3,'0D ()~%~4T(values (char-downcase ~S) (char-upcase ~S))~%~2T(values ~S ~S))~2%"
        code char char
        (char-downcase char) (char-upcase char) ))

(deftest cl-13-14-008 ()
    (values (char-downcase #\Backspace) (char-upcase #\Backspace))
  (values #\Backspace #\Backspace))

(deftest cl-13-14-009 ()
    (values (char-downcase #\Tab) (char-upcase #\Tab))
  (values #\Tab #\Tab))

(deftest cl-13-14-010 ()
    (values (char-downcase #\Newline) (char-upcase #\Newline))
  (values #\Newline #\Newline))

(deftest cl-13-14-012 ()
    (values (char-downcase #\Page) (char-upcase #\Page))
  (values #\Page #\Page))

(deftest cl-13-14-027 ()
    (values (char-downcase #\Escape) (char-upcase #\Escape))
  (values #\Escape #\Escape))

(deftest cl-13-14-032 ()
    (values (char-downcase #\Space) (char-upcase #\Space))
  (values #\Space #\Space))

(deftest cl-13-14-033 ()
    (values (char-downcase #\!) (char-upcase #\!))
  (values #\! #\!))

(deftest cl-13-14-034 ()
    (values (char-downcase #\") (char-upcase #\"))
  (values #\" #\"))

(deftest cl-13-14-035 ()
    (values (char-downcase #\#) (char-upcase #\#))
  (values #\# #\#))

(deftest cl-13-14-036 ()
    (values (char-downcase #\$) (char-upcase #\$))
  (values #\$ #\$))

(deftest cl-13-14-037 ()
    (values (char-downcase #\%) (char-upcase #\%))
  (values #\% #\%))

(deftest cl-13-14-038 ()
    (values (char-downcase #\&) (char-upcase #\&))
  (values #\& #\&))

(deftest cl-13-14-039 ()
    (values (char-downcase #\') (char-upcase #\'))
  (values #\' #\'))

(deftest cl-13-14-040 ()
    (values (char-downcase #\() (char-upcase #\())
  (values #\( #\())

(deftest cl-13-14-041 ()
    (values (char-downcase #\)) (char-upcase #\)))
  (values #\) #\)))

(deftest cl-13-14-042 ()
    (values (char-downcase #\*) (char-upcase #\*))
  (values #\* #\*))

(deftest cl-13-14-043 ()
    (values (char-downcase #\+) (char-upcase #\+))
  (values #\+ #\+))

(deftest cl-13-14-044 ()
    (values (char-downcase #\,) (char-upcase #\,))
  (values #\, #\,))

(deftest cl-13-14-045 ()
    (values (char-downcase #\-) (char-upcase #\-))
  (values #\- #\-))

(deftest cl-13-14-046 ()
    (values (char-downcase #\.) (char-upcase #\.))
  (values #\. #\.))

(deftest cl-13-14-047 ()
    (values (char-downcase #\/) (char-upcase #\/))
  (values #\/ #\/))

(deftest cl-13-14-048 ()
    (values (char-downcase #\0) (char-upcase #\0))
  (values #\0 #\0))

(deftest cl-13-14-049 ()
    (values (char-downcase #\1) (char-upcase #\1))
  (values #\1 #\1))

(deftest cl-13-14-050 ()
    (values (char-downcase #\2) (char-upcase #\2))
  (values #\2 #\2))

(deftest cl-13-14-051 ()
    (values (char-downcase #\3) (char-upcase #\3))
  (values #\3 #\3))

(deftest cl-13-14-052 ()
    (values (char-downcase #\4) (char-upcase #\4))
  (values #\4 #\4))

(deftest cl-13-14-053 ()
    (values (char-downcase #\5) (char-upcase #\5))
  (values #\5 #\5))

(deftest cl-13-14-054 ()
    (values (char-downcase #\6) (char-upcase #\6))
  (values #\6 #\6))

(deftest cl-13-14-055 ()
    (values (char-downcase #\7) (char-upcase #\7))
  (values #\7 #\7))

(deftest cl-13-14-056 ()
    (values (char-downcase #\8) (char-upcase #\8))
  (values #\8 #\8))

(deftest cl-13-14-057 ()
    (values (char-downcase #\9) (char-upcase #\9))
  (values #\9 #\9))

(deftest cl-13-14-058 ()
    (values (char-downcase #\:) (char-upcase #\:))
  (values #\: #\:))

(deftest cl-13-14-059 ()
    (values (char-downcase #\;) (char-upcase #\;))
  (values #\; #\;))

(deftest cl-13-14-060 ()
    (values (char-downcase #\<) (char-upcase #\<))
  (values #\< #\<))

(deftest cl-13-14-061 ()
    (values (char-downcase #\=) (char-upcase #\=))
  (values #\= #\=))

(deftest cl-13-14-062 ()
    (values (char-downcase #\>) (char-upcase #\>))
  (values #\> #\>))

(deftest cl-13-14-063 ()
    (values (char-downcase #\?) (char-upcase #\?))
  (values #\? #\?))

(deftest cl-13-14-064 ()
    (values (char-downcase #\@) (char-upcase #\@))
  (values #\@ #\@))

(deftest cl-13-14-065 ()
    (values (char-downcase #\A) (char-upcase #\A))
  (values #\a #\A))

(deftest cl-13-14-066 ()
    (values (char-downcase #\B) (char-upcase #\B))
  (values #\b #\B))

(deftest cl-13-14-067 ()
    (values (char-downcase #\C) (char-upcase #\C))
  (values #\c #\C))

(deftest cl-13-14-068 ()
    (values (char-downcase #\D) (char-upcase #\D))
  (values #\d #\D))

(deftest cl-13-14-069 ()
    (values (char-downcase #\E) (char-upcase #\E))
  (values #\e #\E))

(deftest cl-13-14-070 ()
    (values (char-downcase #\F) (char-upcase #\F))
  (values #\f #\F))

(deftest cl-13-14-071 ()
    (values (char-downcase #\G) (char-upcase #\G))
  (values #\g #\G))

(deftest cl-13-14-072 ()
    (values (char-downcase #\H) (char-upcase #\H))
  (values #\h #\H))

(deftest cl-13-14-073 ()
    (values (char-downcase #\I) (char-upcase #\I))
  (values #\i #\I))

(deftest cl-13-14-074 ()
    (values (char-downcase #\J) (char-upcase #\J))
  (values #\j #\J))

(deftest cl-13-14-075 ()
    (values (char-downcase #\K) (char-upcase #\K))
  (values #\k #\K))

(deftest cl-13-14-076 ()
    (values (char-downcase #\L) (char-upcase #\L))
  (values #\l #\L))

(deftest cl-13-14-077 ()
    (values (char-downcase #\M) (char-upcase #\M))
  (values #\m #\M))

(deftest cl-13-14-078 ()
    (values (char-downcase #\N) (char-upcase #\N))
  (values #\n #\N))

(deftest cl-13-14-079 ()
    (values (char-downcase #\O) (char-upcase #\O))
  (values #\o #\O))

(deftest cl-13-14-080 ()
    (values (char-downcase #\P) (char-upcase #\P))
  (values #\p #\P))

(deftest cl-13-14-081 ()
    (values (char-downcase #\Q) (char-upcase #\Q))
  (values #\q #\Q))

(deftest cl-13-14-082 ()
    (values (char-downcase #\R) (char-upcase #\R))
  (values #\r #\R))

(deftest cl-13-14-083 ()
    (values (char-downcase #\S) (char-upcase #\S))
  (values #\s #\S))

(deftest cl-13-14-084 ()
    (values (char-downcase #\T) (char-upcase #\T))
  (values #\t #\T))

(deftest cl-13-14-085 ()
    (values (char-downcase #\U) (char-upcase #\U))
  (values #\u #\U))

(deftest cl-13-14-086 ()
    (values (char-downcase #\V) (char-upcase #\V))
  (values #\v #\V))

(deftest cl-13-14-087 ()
    (values (char-downcase #\W) (char-upcase #\W))
  (values #\w #\W))

(deftest cl-13-14-088 ()
    (values (char-downcase #\X) (char-upcase #\X))
  (values #\x #\X))

(deftest cl-13-14-089 ()
    (values (char-downcase #\Y) (char-upcase #\Y))
  (values #\y #\Y))

(deftest cl-13-14-090 ()
    (values (char-downcase #\Z) (char-upcase #\Z))
  (values #\z #\Z))

(deftest cl-13-14-091 ()
    (values (char-downcase #\[) (char-upcase #\[))
  (values #\[ #\[))

(deftest cl-13-14-092 ()
    (values (char-downcase #\\) (char-upcase #\\))
  (values #\\ #\\))

(deftest cl-13-14-093 ()
    (values (char-downcase #\]) (char-upcase #\]))
  (values #\] #\]))

(deftest cl-13-14-094 ()
    (values (char-downcase #\^) (char-upcase #\^))
  (values #\^ #\^))

(deftest cl-13-14-095 ()
    (values (char-downcase #\_) (char-upcase #\_))
  (values #\_ #\_))

(deftest cl-13-14-096 ()
    (values (char-downcase #\`) (char-upcase #\`))
  (values #\` #\`))

(deftest cl-13-14-097 ()
    (values (char-downcase #\a) (char-upcase #\a))
  (values #\a #\A))

(deftest cl-13-14-098 ()
    (values (char-downcase #\b) (char-upcase #\b))
  (values #\b #\B))

(deftest cl-13-14-099 ()
    (values (char-downcase #\c) (char-upcase #\c))
  (values #\c #\C))

(deftest cl-13-14-100 ()
    (values (char-downcase #\d) (char-upcase #\d))
  (values #\d #\D))

(deftest cl-13-14-101 ()
    (values (char-downcase #\e) (char-upcase #\e))
  (values #\e #\E))

(deftest cl-13-14-102 ()
    (values (char-downcase #\f) (char-upcase #\f))
  (values #\f #\F))

(deftest cl-13-14-103 ()
    (values (char-downcase #\g) (char-upcase #\g))
  (values #\g #\G))

(deftest cl-13-14-104 ()
    (values (char-downcase #\h) (char-upcase #\h))
  (values #\h #\H))

(deftest cl-13-14-105 ()
    (values (char-downcase #\i) (char-upcase #\i))
  (values #\i #\I))

(deftest cl-13-14-106 ()
    (values (char-downcase #\j) (char-upcase #\j))
  (values #\j #\J))

(deftest cl-13-14-107 ()
    (values (char-downcase #\k) (char-upcase #\k))
  (values #\k #\K))

(deftest cl-13-14-108 ()
    (values (char-downcase #\l) (char-upcase #\l))
  (values #\l #\L))

(deftest cl-13-14-109 ()
    (values (char-downcase #\m) (char-upcase #\m))
  (values #\m #\M))

(deftest cl-13-14-110 ()
    (values (char-downcase #\n) (char-upcase #\n))
  (values #\n #\N))

(deftest cl-13-14-111 ()
    (values (char-downcase #\o) (char-upcase #\o))
  (values #\o #\O))

(deftest cl-13-14-112 ()
    (values (char-downcase #\p) (char-upcase #\p))
  (values #\p #\P))

(deftest cl-13-14-113 ()
    (values (char-downcase #\q) (char-upcase #\q))
  (values #\q #\Q))

(deftest cl-13-14-114 ()
    (values (char-downcase #\r) (char-upcase #\r))
  (values #\r #\R))

(deftest cl-13-14-115 ()
    (values (char-downcase #\s) (char-upcase #\s))
  (values #\s #\S))

(deftest cl-13-14-116 ()
    (values (char-downcase #\t) (char-upcase #\t))
  (values #\t #\T))

(deftest cl-13-14-117 ()
    (values (char-downcase #\u) (char-upcase #\u))
  (values #\u #\U))

(deftest cl-13-14-118 ()
    (values (char-downcase #\v) (char-upcase #\v))
  (values #\v #\V))

(deftest cl-13-14-119 ()
    (values (char-downcase #\w) (char-upcase #\w))
  (values #\w #\W))

(deftest cl-13-14-120 ()
    (values (char-downcase #\x) (char-upcase #\x))
  (values #\x #\X))

(deftest cl-13-14-121 ()
    (values (char-downcase #\y) (char-upcase #\y))
  (values #\y #\Y))

(deftest cl-13-14-122 ()
    (values (char-downcase #\z) (char-upcase #\z))
  (values #\z #\Z))

(deftest cl-13-14-123 ()
    (values (char-downcase #\{) (char-upcase #\{))
  (values #\{ #\{))

(deftest cl-13-14-124 ()
    (values (char-downcase #\|) (char-upcase #\|))
  (values #\| #\|))

(deftest cl-13-14-125 ()
    (values (char-downcase #\}) (char-upcase #\}))
  (values #\} #\}))

(deftest cl-13-14-126 ()
    (values (char-downcase #\~) (char-upcase #\~))
  (values #\~ #\~))


;;; 13.2.15 lower-case-p, upper-case-p
#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-15-~3,'0D ()~%~4T(values (upper-case-p ~S) (lower-case-p ~S) (both-case-p ~S))~%~2T(values ~S ~S ~S) )~2%"
        code
        char char char
        (upper-case-p char) (lower-case-p char) (both-case-p char) ))

(deftest cl-13-15-008 ()
    (values (bool (upper-case-p #\Backspace))
            (bool (lower-case-p #\Backspace))
            (bool (both-case-p #\Backspace)) )
  (values nil nil nil) )

(deftest cl-13-15-009 ()
    (values (bool (upper-case-p #\Tab))
            (bool (lower-case-p #\Tab))
            (bool (both-case-p #\Tab)) )
  (values nil nil nil) )

(deftest cl-13-15-010 ()
    (values (bool (upper-case-p #\Newline))
            (bool (lower-case-p #\Newline)) 
            (bool (both-case-p #\Newline)) )
  (values nil nil nil) )

(deftest cl-13-15-012 ()
    (values (bool (upper-case-p #\Page))
            (bool (lower-case-p #\Page))
            (bool (both-case-p #\Page)) )
  (values nil nil nil) )

(deftest cl-13-15-027 ()
    (values (bool (upper-case-p #\Escape))  (bool (lower-case-p #\Escape)) 
            (bool (both-case-p #\Escape)) )
  (values nil nil nil) )

(deftest cl-13-15-032 ()
    (values (bool (upper-case-p #\Space))  (bool (lower-case-p #\Space)) 
            (bool (both-case-p #\Space)) )
  (values nil nil nil) )

(deftest cl-13-15-033 ()
    (values (bool (upper-case-p #\!))  (bool (lower-case-p #\!))  (bool (both-case-p #\!)) )
  (values nil nil nil) )

(deftest cl-13-15-034 ()
    (values (bool (upper-case-p #\"))  (bool (lower-case-p #\"))  (bool (both-case-p #\")) )
  (values nil nil nil) )

(deftest cl-13-15-035 ()
    (values (bool (upper-case-p #\#))  (bool (lower-case-p #\#))  (bool (both-case-p #\#)) )
  (values nil nil nil) )

(deftest cl-13-15-036 ()
    (values (bool (upper-case-p #\$))  (bool (lower-case-p #\$))  (bool (both-case-p #\$)) )
  (values nil nil nil) )

(deftest cl-13-15-037 ()
    (values (bool (upper-case-p #\%))  (bool (lower-case-p #\%))  (bool (both-case-p #\%)) )
  (values nil nil nil) )

(deftest cl-13-15-038 ()
    (values (bool (upper-case-p #\&))  (bool (lower-case-p #\&))  (bool (both-case-p #\&)) )
  (values nil nil nil) )

(deftest cl-13-15-039 ()
    (values (bool (upper-case-p #\'))  (bool (lower-case-p #\'))  (bool (both-case-p #\')) )
  (values nil nil nil) )

(deftest cl-13-15-040 ()
    (values (bool (upper-case-p #\())  (bool (lower-case-p #\())  (bool (both-case-p #\()) )
  (values nil nil nil) )

(deftest cl-13-15-041 ()
    (values (bool (upper-case-p #\)))
            (bool (lower-case-p #\)))
            (bool (both-case-p  #\))) )
  (values nil nil nil) )

(deftest cl-13-15-042 ()
    (values (bool (upper-case-p #\*))  (bool (lower-case-p #\*))  (bool (both-case-p #\*)) )
  (values nil nil nil) )

(deftest cl-13-15-043 ()
    (values (bool (upper-case-p #\+))  (bool (lower-case-p #\+))  (bool (both-case-p #\+)) )
  (values nil nil nil) )

(deftest cl-13-15-044 ()
    (values (bool (upper-case-p #\,))  (bool (lower-case-p #\,))  (bool (both-case-p #\,)) )
  (values nil nil nil) )

(deftest cl-13-15-045 ()
    (values (bool (upper-case-p #\-))  (bool (lower-case-p #\-))  (bool (both-case-p #\-)) )
  (values nil nil nil) )

(deftest cl-13-15-046 ()
    (values (bool (upper-case-p #\.))  (bool (lower-case-p #\.))  (bool (both-case-p #\.)) )
  (values nil nil nil) )

(deftest cl-13-15-047 ()
    (values (bool (upper-case-p #\/))  (bool (lower-case-p #\/))  (bool (both-case-p #\/)) )
  (values nil nil nil) )

(deftest cl-13-15-048 ()
    (values (bool (upper-case-p #\0))  (bool (lower-case-p #\0))  (bool (both-case-p #\0)) )
  (values nil nil nil) )

(deftest cl-13-15-049 ()
    (values (bool (upper-case-p #\1))  (bool (lower-case-p #\1))  (bool (both-case-p #\1)) )
  (values nil nil nil) )

(deftest cl-13-15-050 ()
    (values (bool (upper-case-p #\2))  (bool (lower-case-p #\2))  (bool (both-case-p #\2)) )
  (values nil nil nil) )

(deftest cl-13-15-051 ()
    (values (bool (upper-case-p #\3))  (bool (lower-case-p #\3))  (bool (both-case-p #\3)) )
  (values nil nil nil) )

(deftest cl-13-15-052 ()
    (values (bool (upper-case-p #\4))  (bool (lower-case-p #\4))  (bool (both-case-p #\4)) )
  (values nil nil nil) )

(deftest cl-13-15-053 ()
    (values (bool (upper-case-p #\5))  (bool (lower-case-p #\5))  (bool (both-case-p #\5)) )
  (values nil nil nil) )

(deftest cl-13-15-054 ()
    (values (bool (upper-case-p #\6))  (bool (lower-case-p #\6))  (bool (both-case-p #\6)) )
  (values nil nil nil) )

(deftest cl-13-15-055 ()
    (values (bool (upper-case-p #\7))  (bool (lower-case-p #\7))  (bool (both-case-p #\7)) )
  (values nil nil nil) )

(deftest cl-13-15-056 ()
    (values (bool (upper-case-p #\8))  (bool (lower-case-p #\8))  (bool (both-case-p #\8)) )
  (values nil nil nil) )

(deftest cl-13-15-057 ()
    (values (bool (upper-case-p #\9))  (bool (lower-case-p #\9))  (bool (both-case-p #\9)) )
  (values nil nil nil) )

(deftest cl-13-15-058 ()
    (values (bool (upper-case-p #\:))  (bool (lower-case-p #\:))  (bool (both-case-p #\:)) )
  (values nil nil nil) )

(deftest cl-13-15-059 ()
    (values (bool (upper-case-p #\;))  (bool (lower-case-p #\;))  (bool (both-case-p #\;)) )
  (values nil nil nil) )

(deftest cl-13-15-060 ()
    (values (bool (upper-case-p #\<))  (bool (lower-case-p #\<))  (bool (both-case-p #\<)) )
  (values nil nil nil) )

(deftest cl-13-15-061 ()
    (values (bool (upper-case-p #\=))  (bool (lower-case-p #\=))  (bool (both-case-p #\=)) )
  (values nil nil nil) )

(deftest cl-13-15-062 ()
    (values (bool (upper-case-p #\>))  (bool (lower-case-p #\>))  (bool (both-case-p #\>)) )
  (values nil nil nil) )

(deftest cl-13-15-063 ()
    (values (bool (upper-case-p #\?))  (bool (lower-case-p #\?))  (bool (both-case-p #\?)) )
  (values nil nil nil) )

(deftest cl-13-15-064 ()
    (values (bool (upper-case-p #\@))  (bool (lower-case-p #\@))  (bool (both-case-p #\@)) )
  (values nil nil nil) )

(deftest cl-13-15-065 ()
    (values (bool (upper-case-p #\A))  (bool (lower-case-p #\A))  (bool (both-case-p #\A)) )
  (values T nil T) )

(deftest cl-13-15-066 ()
    (values (bool (upper-case-p #\B))  (bool (lower-case-p #\B))  (bool (both-case-p #\B)) )
  (values T nil T) )

(deftest cl-13-15-067 ()
    (values (bool (upper-case-p #\C))  (bool (lower-case-p #\C))  (bool (both-case-p #\C)) )
  (values T nil T) )

(deftest cl-13-15-068 ()
    (values (bool (upper-case-p #\D))  (bool (lower-case-p #\D))  (bool (both-case-p #\D)) )
  (values T nil T) )

(deftest cl-13-15-069 ()
    (values (bool (upper-case-p #\E))  (bool (lower-case-p #\E))  (bool (both-case-p #\E)) )
  (values T nil T) )

(deftest cl-13-15-070 ()
    (values (bool (upper-case-p #\F))  (bool (lower-case-p #\F))  (bool (both-case-p #\F)) )
  (values T nil T) )

(deftest cl-13-15-071 ()
    (values (bool (upper-case-p #\G))  (bool (lower-case-p #\G))  (bool (both-case-p #\G)) )
  (values T nil T) )

(deftest cl-13-15-072 ()
    (values (bool (upper-case-p #\H))  (bool (lower-case-p #\H))  (bool (both-case-p #\H)) )
  (values T nil T) )

(deftest cl-13-15-073 ()
    (values (bool (upper-case-p #\I))  (bool (lower-case-p #\I))  (bool (both-case-p #\I)) )
  (values T nil T) )

(deftest cl-13-15-074 ()
    (values (bool (upper-case-p #\J))  (bool (lower-case-p #\J))  (bool (both-case-p #\J)) )
  (values T nil T) )

(deftest cl-13-15-075 ()
    (values (bool (upper-case-p #\K))  (bool (lower-case-p #\K))  (bool (both-case-p #\K)) )
  (values T nil T) )

(deftest cl-13-15-076 ()
    (values (bool (upper-case-p #\L))  (bool (lower-case-p #\L))  (bool (both-case-p #\L)) )
  (values T nil T) )

(deftest cl-13-15-077 ()
    (values (bool (upper-case-p #\M))  (bool (lower-case-p #\M))  (bool (both-case-p #\M)) )
  (values T nil T) )

(deftest cl-13-15-078 ()
    (values (bool (upper-case-p #\N))  (bool (lower-case-p #\N))  (bool (both-case-p #\N)) )
  (values T nil T) )

(deftest cl-13-15-079 ()
    (values (bool (upper-case-p #\O))  (bool (lower-case-p #\O))  (bool (both-case-p #\O)) )
  (values T nil T) )

(deftest cl-13-15-080 ()
    (values (bool (upper-case-p #\P))  (bool (lower-case-p #\P))  (bool (both-case-p #\P)) )
  (values T nil T) )

(deftest cl-13-15-081 ()
    (values (bool (upper-case-p #\Q))  (bool (lower-case-p #\Q))  (bool (both-case-p #\Q)) )
  (values T nil T) )

(deftest cl-13-15-082 ()
    (values (bool (upper-case-p #\R))  (bool (lower-case-p #\R))  (bool (both-case-p #\R)) )
  (values T nil T) )

(deftest cl-13-15-083 ()
    (values (bool (upper-case-p #\S))  (bool (lower-case-p #\S))  (bool (both-case-p #\S)) )
  (values T nil T) )

(deftest cl-13-15-084 ()
    (values (bool (upper-case-p #\T))  (bool (lower-case-p #\T))  (bool (both-case-p #\T)) )
  (values T nil T) )

(deftest cl-13-15-085 ()
    (values (bool (upper-case-p #\U))  (bool (lower-case-p #\U))  (bool (both-case-p #\U)) )
  (values T nil T) )

(deftest cl-13-15-086 ()
    (values (bool (upper-case-p #\V))  (bool (lower-case-p #\V))  (bool (both-case-p #\V)) )
  (values T nil T) )

(deftest cl-13-15-087 ()
    (values (bool (upper-case-p #\W))  (bool (lower-case-p #\W))  (bool (both-case-p #\W)) )
  (values T nil T) )

(deftest cl-13-15-088 ()
    (values (bool (upper-case-p #\X))  (bool (lower-case-p #\X))  (bool (both-case-p #\X)) )
  (values T nil T) )

(deftest cl-13-15-089 ()
    (values (bool (upper-case-p #\Y))  (bool (lower-case-p #\Y))  (bool (both-case-p #\Y)) )
  (values T nil T) )

(deftest cl-13-15-090 ()
    (values (bool (upper-case-p #\Z))  (bool (lower-case-p #\Z))  (bool (both-case-p #\Z)) )
  (values T nil T) )

(deftest cl-13-15-091 ()
    (values (bool (upper-case-p #\[))  (bool (lower-case-p #\[))  (bool (both-case-p #\[)) )
  (values nil nil nil) )

(deftest cl-13-15-092 ()
    (values (bool (upper-case-p #\\))  (bool (lower-case-p #\\))  (bool (both-case-p #\\)) )
  (values nil nil nil) )

(deftest cl-13-15-093 ()
    (values (bool (upper-case-p #\]))  (bool (lower-case-p #\]))  (bool (both-case-p #\])) )
  (values nil nil nil) )

(deftest cl-13-15-094 ()
    (values (bool (upper-case-p #\^))  (bool (lower-case-p #\^))  (bool (both-case-p #\^)) )
  (values nil nil nil) )

(deftest cl-13-15-095 ()
    (values (bool (upper-case-p #\_))  (bool (lower-case-p #\_))  (bool (both-case-p #\_)) )
  (values nil nil nil) )

(deftest cl-13-15-096 ()
    (values (bool (upper-case-p #\`))  (bool (lower-case-p #\`))  (bool (both-case-p #\`)) )
  (values nil nil nil) )

(deftest cl-13-15-097 ()
    (values (bool (upper-case-p #\a))  (bool (lower-case-p #\a))  (bool (both-case-p #\a)) )
  (values nil T T) )

(deftest cl-13-15-098 ()
    (values (bool (upper-case-p #\b))  (bool (lower-case-p #\b))  (bool (both-case-p #\b)) )
  (values nil T T) )

(deftest cl-13-15-099 ()
    (values (bool (upper-case-p #\c))  (bool (lower-case-p #\c))  (bool (both-case-p #\c)) )
  (values nil T T) )

(deftest cl-13-15-100 ()
    (values (bool (upper-case-p #\d))  (bool (lower-case-p #\d))  (bool (both-case-p #\d)) )
  (values nil T T) )

(deftest cl-13-15-101 ()
    (values (bool (upper-case-p #\e))  (bool (lower-case-p #\e))  (bool (both-case-p #\e)) )
  (values nil T T) )

(deftest cl-13-15-102 ()
    (values (bool (upper-case-p #\f))  (bool (lower-case-p #\f))  (bool (both-case-p #\f)) )
  (values nil T T) )

(deftest cl-13-15-103 ()
    (values (bool (upper-case-p #\g))  (bool (lower-case-p #\g))  (bool (both-case-p #\g)) )
  (values nil T T) )

(deftest cl-13-15-104 ()
    (values (bool (upper-case-p #\h))  (bool (lower-case-p #\h))  (bool (both-case-p #\h)) )
  (values nil T T) )

(deftest cl-13-15-105 ()
    (values (bool (upper-case-p #\i))  (bool (lower-case-p #\i))  (bool (both-case-p #\i)) )
  (values nil T T) )

(deftest cl-13-15-106 ()
    (values (bool (upper-case-p #\j))  (bool (lower-case-p #\j))  (bool (both-case-p #\j)) )
  (values nil T T) )

(deftest cl-13-15-107 ()
    (values (bool (upper-case-p #\k))  (bool (lower-case-p #\k))  (bool (both-case-p #\k)) )
  (values nil T T) )

(deftest cl-13-15-108 ()
    (values (bool (upper-case-p #\l))  (bool (lower-case-p #\l))  (bool (both-case-p #\l)) )
  (values nil T T) )

(deftest cl-13-15-109 ()
    (values (bool (upper-case-p #\m))  (bool (lower-case-p #\m))  (bool (both-case-p #\m)) )
  (values nil T T) )

(deftest cl-13-15-110 ()
    (values (bool (upper-case-p #\n))  (bool (lower-case-p #\n))  (bool (both-case-p #\n)) )
  (values nil T T) )

(deftest cl-13-15-111 ()
    (values (bool (upper-case-p #\o))  (bool (lower-case-p #\o))  (bool (both-case-p #\o)) )
  (values nil T T) )

(deftest cl-13-15-112 ()
    (values (bool (upper-case-p #\p))  (bool (lower-case-p #\p))  (bool (both-case-p #\p)) )
  (values nil T T) )

(deftest cl-13-15-113 ()
    (values (bool (upper-case-p #\q))  (bool (lower-case-p #\q))  (bool (both-case-p #\q)) )
  (values nil T T) )

(deftest cl-13-15-114 ()
    (values (bool (upper-case-p #\r))  (bool (lower-case-p #\r))  (bool (both-case-p #\r)) )
  (values nil T T) )

(deftest cl-13-15-115 ()
    (values (bool (upper-case-p #\s))  (bool (lower-case-p #\s))  (bool (both-case-p #\s)) )
  (values nil T T) )

(deftest cl-13-15-116 ()
    (values (bool (upper-case-p #\t))  (bool (lower-case-p #\t))  (bool (both-case-p #\t)) )
  (values nil T T) )

(deftest cl-13-15-117 ()
    (values (bool (upper-case-p #\u))  (bool (lower-case-p #\u))  (bool (both-case-p #\u)) )
  (values nil T T) )

(deftest cl-13-15-118 ()
    (values (bool (upper-case-p #\v))  (bool (lower-case-p #\v))  (bool (both-case-p #\v)) )
  (values nil T T) )

(deftest cl-13-15-119 ()
    (values (bool (upper-case-p #\w))  (bool (lower-case-p #\w))  (bool (both-case-p #\w)) )
  (values nil T T) )

(deftest cl-13-15-120 ()
    (values (bool (upper-case-p #\x))  (bool (lower-case-p #\x))  (bool (both-case-p #\x)) )
  (values nil T T) )

(deftest cl-13-15-121 ()
    (values (bool (upper-case-p #\y))  (bool (lower-case-p #\y))  (bool (both-case-p #\y)) )
  (values nil T T) )

(deftest cl-13-15-122 ()
    (values (bool (upper-case-p #\z))  (bool (lower-case-p #\z))  (bool (both-case-p #\z)) )
  (values nil T T) )

(deftest cl-13-15-123 ()
    (values (bool (upper-case-p #\{))  (bool (lower-case-p #\{))  (bool (both-case-p #\{)) )
  (values nil nil nil) )

(deftest cl-13-15-124 ()
    (values (bool (upper-case-p #\|))  (bool (lower-case-p #\|))  (bool (both-case-p #\|)) )
  (values nil nil nil) )

(deftest cl-13-15-125 ()
    (values (bool (upper-case-p #\}))  (bool (lower-case-p #\}))  (bool (both-case-p #\})) )
  (values nil nil nil) )

(deftest cl-13-15-126 ()
    (values (bool (upper-case-p #\~))  (bool (lower-case-p #\~))  (bool (both-case-p #\~)) )
  (values nil nil nil) )


;;; 13.2.16 char-code
#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-16-~3,'0D () (char-code ~S) #x~2,'0X)~%"
        code char code ))

(deftest cl-13-16-008 () (char-code #\Backspace) #x08)
(deftest cl-13-16-009 () (char-code #\Tab) #x09)
(deftest cl-13-16-010 () (char-code #\Newline) #x0A)
(deftest cl-13-16-012 () (char-code #\Page) #x0C)
(deftest cl-13-16-027 () (char-code #\Escape) #x1B)
(deftest cl-13-16-032 () (char-code #\Space) #x20)
(deftest cl-13-16-033 () (char-code #\!) #x21)
(deftest cl-13-16-034 () (char-code #\") #x22)
(deftest cl-13-16-035 () (char-code #\#) #x23)
(deftest cl-13-16-036 () (char-code #\$) #x24)
(deftest cl-13-16-037 () (char-code #\%) #x25)
(deftest cl-13-16-038 () (char-code #\&) #x26)
(deftest cl-13-16-039 () (char-code #\') #x27)
(deftest cl-13-16-040 () (char-code #\() #x28)
(deftest cl-13-16-041 () (char-code #\)) #x29)
(deftest cl-13-16-042 () (char-code #\*) #x2A)
(deftest cl-13-16-043 () (char-code #\+) #x2B)
(deftest cl-13-16-044 () (char-code #\,) #x2C)
(deftest cl-13-16-045 () (char-code #\-) #x2D)
(deftest cl-13-16-046 () (char-code #\.) #x2E)
(deftest cl-13-16-047 () (char-code #\/) #x2F)
(deftest cl-13-16-048 () (char-code #\0) #x30)
(deftest cl-13-16-049 () (char-code #\1) #x31)
(deftest cl-13-16-050 () (char-code #\2) #x32)
(deftest cl-13-16-051 () (char-code #\3) #x33)
(deftest cl-13-16-052 () (char-code #\4) #x34)
(deftest cl-13-16-053 () (char-code #\5) #x35)
(deftest cl-13-16-054 () (char-code #\6) #x36)
(deftest cl-13-16-055 () (char-code #\7) #x37)
(deftest cl-13-16-056 () (char-code #\8) #x38)
(deftest cl-13-16-057 () (char-code #\9) #x39)
(deftest cl-13-16-058 () (char-code #\:) #x3A)
(deftest cl-13-16-059 () (char-code #\;) #x3B)
(deftest cl-13-16-060 () (char-code #\<) #x3C)
(deftest cl-13-16-061 () (char-code #\=) #x3D)
(deftest cl-13-16-062 () (char-code #\>) #x3E)
(deftest cl-13-16-063 () (char-code #\?) #x3F)
(deftest cl-13-16-064 () (char-code #\@) #x40)
(deftest cl-13-16-065 () (char-code #\A) #x41)
(deftest cl-13-16-066 () (char-code #\B) #x42)
(deftest cl-13-16-067 () (char-code #\C) #x43)
(deftest cl-13-16-068 () (char-code #\D) #x44)
(deftest cl-13-16-069 () (char-code #\E) #x45)
(deftest cl-13-16-070 () (char-code #\F) #x46)
(deftest cl-13-16-071 () (char-code #\G) #x47)
(deftest cl-13-16-072 () (char-code #\H) #x48)
(deftest cl-13-16-073 () (char-code #\I) #x49)
(deftest cl-13-16-074 () (char-code #\J) #x4A)
(deftest cl-13-16-075 () (char-code #\K) #x4B)
(deftest cl-13-16-076 () (char-code #\L) #x4C)
(deftest cl-13-16-077 () (char-code #\M) #x4D)
(deftest cl-13-16-078 () (char-code #\N) #x4E)
(deftest cl-13-16-079 () (char-code #\O) #x4F)
(deftest cl-13-16-080 () (char-code #\P) #x50)
(deftest cl-13-16-081 () (char-code #\Q) #x51)
(deftest cl-13-16-082 () (char-code #\R) #x52)
(deftest cl-13-16-083 () (char-code #\S) #x53)
(deftest cl-13-16-084 () (char-code #\T) #x54)
(deftest cl-13-16-085 () (char-code #\U) #x55)
(deftest cl-13-16-086 () (char-code #\V) #x56)
(deftest cl-13-16-087 () (char-code #\W) #x57)
(deftest cl-13-16-088 () (char-code #\X) #x58)
(deftest cl-13-16-089 () (char-code #\Y) #x59)
(deftest cl-13-16-090 () (char-code #\Z) #x5A)
(deftest cl-13-16-091 () (char-code #\[) #x5B)
(deftest cl-13-16-092 () (char-code #\\) #x5C)
(deftest cl-13-16-093 () (char-code #\]) #x5D)
(deftest cl-13-16-094 () (char-code #\^) #x5E)
(deftest cl-13-16-095 () (char-code #\_) #x5F)
(deftest cl-13-16-096 () (char-code #\`) #x60)
(deftest cl-13-16-097 () (char-code #\a) #x61)
(deftest cl-13-16-098 () (char-code #\b) #x62)
(deftest cl-13-16-099 () (char-code #\c) #x63)
(deftest cl-13-16-100 () (char-code #\d) #x64)
(deftest cl-13-16-101 () (char-code #\e) #x65)
(deftest cl-13-16-102 () (char-code #\f) #x66)
(deftest cl-13-16-103 () (char-code #\g) #x67)
(deftest cl-13-16-104 () (char-code #\h) #x68)
(deftest cl-13-16-105 () (char-code #\i) #x69)
(deftest cl-13-16-106 () (char-code #\j) #x6A)
(deftest cl-13-16-107 () (char-code #\k) #x6B)
(deftest cl-13-16-108 () (char-code #\l) #x6C)
(deftest cl-13-16-109 () (char-code #\m) #x6D)
(deftest cl-13-16-110 () (char-code #\n) #x6E)
(deftest cl-13-16-111 () (char-code #\o) #x6F)
(deftest cl-13-16-112 () (char-code #\p) #x70)
(deftest cl-13-16-113 () (char-code #\q) #x71)
(deftest cl-13-16-114 () (char-code #\r) #x72)
(deftest cl-13-16-115 () (char-code #\s) #x73)
(deftest cl-13-16-116 () (char-code #\t) #x74)
(deftest cl-13-16-117 () (char-code #\u) #x75)
(deftest cl-13-16-118 () (char-code #\v) #x76)
(deftest cl-13-16-119 () (char-code #\w) #x77)
(deftest cl-13-16-120 () (char-code #\x) #x78)
(deftest cl-13-16-121 () (char-code #\y) #x79)
(deftest cl-13-16-122 () (char-code #\z) #x7A)
(deftest cl-13-16-123 () (char-code #\{) #x7B)
(deftest cl-13-16-124 () (char-code #\|) #x7C)
(deftest cl-13-16-125 () (char-code #\}) #x7D)
(deftest cl-13-16-126 () (char-code #\~) #x7E)


;;; 13.2.18 code-char
#+nil
(loop
  for code from 0 below 127
  for char = (code-char code)
    unless (ext:regex-match "u.+" (char-name char)) do
      (format t "(deftest cl-13-18-~3,'0D () (code-char #x~2,'0X) ~S)~%"
        code code char ))

(deftest cl-13-18-001 () (code-char nil) :error type-error)
(deftest cl-13-18-002 () (code-char 'foo) :error type-error)
(deftest cl-13-18-003 () (code-char '(1 2)) :error type-error)
(deftest cl-13-18-004 () (code-char #(1 2)) :error type-error)

(deftest cl-13-18-008 () (code-char #x08) #\Backspace)
(deftest cl-13-18-009 () (code-char #x09) #\Tab)
(deftest cl-13-18-010 () (code-char #x0A) #\Newline)
(deftest cl-13-18-012 () (code-char #x0C) #\Page)
(deftest cl-13-18-027 () (code-char #x1B) #\Escape)
(deftest cl-13-18-032 () (code-char #x20) #\Space)
(deftest cl-13-18-033 () (code-char #x21) #\!)
(deftest cl-13-18-034 () (code-char #x22) #\")
(deftest cl-13-18-035 () (code-char #x23) #\#)
(deftest cl-13-18-036 () (code-char #x24) #\$)
(deftest cl-13-18-037 () (code-char #x25) #\%)
(deftest cl-13-18-038 () (code-char #x26) #\&)
(deftest cl-13-18-039 () (code-char #x27) #\')
(deftest cl-13-18-040 () (code-char #x28) #\()
(deftest cl-13-18-041 () (code-char #x29) #\))
(deftest cl-13-18-042 () (code-char #x2A) #\*)
(deftest cl-13-18-043 () (code-char #x2B) #\+)
(deftest cl-13-18-044 () (code-char #x2C) #\,)
(deftest cl-13-18-045 () (code-char #x2D) #\-)
(deftest cl-13-18-046 () (code-char #x2E) #\.)
(deftest cl-13-18-047 () (code-char #x2F) #\/)
(deftest cl-13-18-048 () (code-char #x30) #\0)
(deftest cl-13-18-049 () (code-char #x31) #\1)
(deftest cl-13-18-050 () (code-char #x32) #\2)
(deftest cl-13-18-051 () (code-char #x33) #\3)
(deftest cl-13-18-052 () (code-char #x34) #\4)
(deftest cl-13-18-053 () (code-char #x35) #\5)
(deftest cl-13-18-054 () (code-char #x36) #\6)
(deftest cl-13-18-055 () (code-char #x37) #\7)
(deftest cl-13-18-056 () (code-char #x38) #\8)
(deftest cl-13-18-057 () (code-char #x39) #\9)
(deftest cl-13-18-058 () (code-char #x3A) #\:)
(deftest cl-13-18-059 () (code-char #x3B) #\;)
(deftest cl-13-18-060 () (code-char #x3C) #\<)
(deftest cl-13-18-061 () (code-char #x3D) #\=)
(deftest cl-13-18-062 () (code-char #x3E) #\>)
(deftest cl-13-18-063 () (code-char #x3F) #\?)
(deftest cl-13-18-064 () (code-char #x40) #\@)
(deftest cl-13-18-065 () (code-char #x41) #\A)
(deftest cl-13-18-066 () (code-char #x42) #\B)
(deftest cl-13-18-067 () (code-char #x43) #\C)
(deftest cl-13-18-068 () (code-char #x44) #\D)
(deftest cl-13-18-069 () (code-char #x45) #\E)
(deftest cl-13-18-070 () (code-char #x46) #\F)
(deftest cl-13-18-071 () (code-char #x47) #\G)
(deftest cl-13-18-072 () (code-char #x48) #\H)
(deftest cl-13-18-073 () (code-char #x49) #\I)
(deftest cl-13-18-074 () (code-char #x4A) #\J)
(deftest cl-13-18-075 () (code-char #x4B) #\K)
(deftest cl-13-18-076 () (code-char #x4C) #\L)
(deftest cl-13-18-077 () (code-char #x4D) #\M)
(deftest cl-13-18-078 () (code-char #x4E) #\N)
(deftest cl-13-18-079 () (code-char #x4F) #\O)
(deftest cl-13-18-080 () (code-char #x50) #\P)
(deftest cl-13-18-081 () (code-char #x51) #\Q)
(deftest cl-13-18-082 () (code-char #x52) #\R)
(deftest cl-13-18-083 () (code-char #x53) #\S)
(deftest cl-13-18-084 () (code-char #x54) #\T)
(deftest cl-13-18-085 () (code-char #x55) #\U)
(deftest cl-13-18-086 () (code-char #x56) #\V)
(deftest cl-13-18-087 () (code-char #x57) #\W)
(deftest cl-13-18-088 () (code-char #x58) #\X)
(deftest cl-13-18-089 () (code-char #x59) #\Y)
(deftest cl-13-18-090 () (code-char #x5A) #\Z)
(deftest cl-13-18-091 () (code-char #x5B) #\[)
(deftest cl-13-18-092 () (code-char #x5C) #\\)
(deftest cl-13-18-093 () (code-char #x5D) #\])
(deftest cl-13-18-094 () (code-char #x5E) #\^)
(deftest cl-13-18-095 () (code-char #x5F) #\_)
(deftest cl-13-18-096 () (code-char #x60) #\`)
(deftest cl-13-18-097 () (code-char #x61) #\a)
(deftest cl-13-18-098 () (code-char #x62) #\b)
(deftest cl-13-18-099 () (code-char #x63) #\c)
(deftest cl-13-18-100 () (code-char #x64) #\d)
(deftest cl-13-18-101 () (code-char #x65) #\e)
(deftest cl-13-18-102 () (code-char #x66) #\f)
(deftest cl-13-18-103 () (code-char #x67) #\g)
(deftest cl-13-18-104 () (code-char #x68) #\h)
(deftest cl-13-18-105 () (code-char #x69) #\i)
(deftest cl-13-18-106 () (code-char #x6A) #\j)
(deftest cl-13-18-107 () (code-char #x6B) #\k)
(deftest cl-13-18-108 () (code-char #x6C) #\l)
(deftest cl-13-18-109 () (code-char #x6D) #\m)
(deftest cl-13-18-110 () (code-char #x6E) #\n)
(deftest cl-13-18-111 () (code-char #x6F) #\o)
(deftest cl-13-18-112 () (code-char #x70) #\p)
(deftest cl-13-18-113 () (code-char #x71) #\q)
(deftest cl-13-18-114 () (code-char #x72) #\r)
(deftest cl-13-18-115 () (code-char #x73) #\s)
(deftest cl-13-18-116 () (code-char #x74) #\t)
(deftest cl-13-18-117 () (code-char #x75) #\u)
(deftest cl-13-18-118 () (code-char #x76) #\v)
(deftest cl-13-18-119 () (code-char #x77) #\w)
(deftest cl-13-18-120 () (code-char #x78) #\x)
(deftest cl-13-18-121 () (code-char #x79) #\y)
(deftest cl-13-18-122 () (code-char #x7A) #\z)
(deftest cl-13-18-123 () (code-char #x7B) #\{)
(deftest cl-13-18-124 () (code-char #x7C) #\|)
(deftest cl-13-18-125 () (code-char #x7D) #\})
(deftest cl-13-18-126 () (code-char #x7E) #\~)
